package Verwaltung.Rechtecontroler;

import java.util.ArrayList;
import java.util.List;

import Verwaltung.Daten.Aktivitaet;
import Verwaltung.Daten.Klasse;
import Verwaltung.Daten.Lehrer;
import Verwaltung.Daten.Interfaces.IAktivitaet;
import Verwaltung.Daten.Interfaces.IKlasse;
import Verwaltung.Daten.Interfaces.ILehrkraft;
import Verwaltung.Datencontroler.Datencontroler;
import Verwaltung.Datencontroler.IDBObjekt;

public class Rechtecontroler {

	/**
	 * Der Datencontroler dem die Aufforderungen übergeben werden.
	 */
	private final Datencontroler operator;

	/**
	 * Der aktuell eingeloggte User, wird nicht ueber den Konstruktor sondern
	 * der login-Methode bestimmt
	 */
	private ILehrkraft user = null;

	/**
	 * Gibt an ob ein User eingeloggt ist, 1 = eingeloggt, 0 = nicht eingeloggt
	 */
	private int loginLvl = -1;

	/**
	 * Konstruktor der Klasse, bekommt einen Datencontroler uebergeben dem dann
	 * ggf. Aufforderungen uebergeben werden
	 * 
	 * @param pControler
	 *            der jeweilig verwendete Datencontroler
	 */
	public Rechtecontroler() {
		operator = new Datencontroler();
	}

	/**
	 * Versucht die Person einzuloggen mit gegebenem Namen und Passwort. Ist
	 * bereits jemand eingeloggt wird überprüft ob die Person, die sich
	 * einloggen will Permissionlevel 1 hat. In diesem Fall wird die eingeloggte
	 * Person raus geworfen und die Person kann sich einloggen, andernfalls wird
	 * eine PermissionException geworfen und der Login wird verweigert.
	 * 
	 * @param loginName
	 *            Name mit dem sich die Person einloggen will
	 * @param loginPasswort
	 *            Passwort mit dem sich die Person einloggen will
	 * @return true wenn login erfolgreich, false wenn login fehlgeschlagen
	 * @throws PermissionException
	 *             wenn zugriff verweigert wurde
	 * @throws IllegalAccessException
	 */
	public boolean login(final String loginName, final String loginPasswort)
			throws PermissionException, IllegalArgumentException {
		ILehrkraft l = null;
		if (operator.login(loginName, loginPasswort)) {
			if (operator.getLehrkraftByLoginName(loginName) != null) {
				l = operator.getLehrkraftByLoginName(loginName);
			} else {
				l = operator.getLehrkraftByLoginName(loginName);
			}
		} else {
			throw new PermissionException("Loginname or Password incorrect");
		}
		if (l != null) {
			if (user == null) {
				user = l;
				loginLvl = l.getPermissionLvl();
				return true;
			} else if (l.getPermissionLvl() == 1) {
				try {
					this.logout();
					user = l;
					loginLvl = l.getPermissionLvl();
					return true;
				} catch (final IllegalArgumentException e) {
					user = l;
					loginLvl = l.getPermissionLvl();
					return true;
				}
			} else {
				throw new PermissionException(
						"Another User is currently logged in. Your Permissionlevel ist not high enough to kick him out!");
			}
		}
		return false;
	}

	/**
	 * Gibt einen int zurueck, der den Loginstatus des User repraesentiert
	 * 
	 * @return -1 nicht eingeloggt, 0 normaler User eingeloggt, 1 editierender
	 *         User eingeloggt
	 */
	public int getLoginlevel() {
		return loginLvl;
	}

	// /**
	// * Soll Datencontroler zum speichern auffordern
	// */
	// public void speichern() {
	//
	// }

	/**
	 * Loggt den aktuellen User aus
	 * 
	 * @return true wenn ausloggen erfolgreich, false wenn ausloggen misslungen
	 * @throws IllegalArgumentException
	 *             geworfen wenn niemand eingeloggt ist der ausgeloggt werden
	 *             koennte
	 */
	public boolean logout() throws IllegalArgumentException {
		if (user != null) {
			user = null;
			loginLvl = -1;
			return true;
		} else {
			throw new IllegalArgumentException("There is nothing to Logout");
		}
	}

	/**
	 * Aufruf von addLeher Permissionlvl: 1
	 * 
	 * @param loginName
	 *            eindeutiger Name für den Leherer
	 * @param name
	 *            Name des Leherers
	 * @param stundenProWoche
	 *            Anzahl der Stunden die ein Lehrer pro Woche arbeiten darf
	 * @param password
	 *            das Passwort des Lehrers
	 * @param permissionLvl
	 *            die Berechtigungsstufe des Lehrers
	 * @throws PermissionException
	 *             wenn getLoginlevel() < Permissionlvl
	 */
	public void addLehrer(final String loginName, final String name,
			final int stundenProWoche, final String password,
			final int permissionlvl) throws PermissionException {
		if (loginLvl == 1) {
			operator.schreibeInDB(new Lehrer(loginName, stundenProWoche, name,
					password, permissionlvl));
		} else {
			throw new PermissionException(
					"You have no Permission to add an Lehrer");
		}

	}

	/**
	 * Aufruf von editLehrer Permissionlvl: 1
	 * 
	 * @param lehrkraft
	 *            lehrkraft die geändert werden soll
	 * @param neuerLogin
	 *            neuer eindeutiger Name des Lehrers
	 * @param name
	 *            neuer Name des Leherers
	 * @param stundenProWoche
	 *            neue Anzahl der Stunden die ein Lehrer pro Woche arbeiten darf
	 * @param password
	 *            das neue Passwort des Lehrers
	 * @param permissionLvl
	 *            die neue Berechtigungsstufe des Lehrers
	 * @param unterrichtserlaubnis
	 *            true wenn die lehrkraft weiterhin unterrichten darf, false
	 *            wenn nicht
	 * @throws PermissionException
	 *             wenn getLoginlevel() < Permissionlvl
	 */
	public void editLehrkraft(final String loginName, final String neuerLogin,
			final String name, final int stundenProWoche,
			final String password, final int permissionLvl,
			final boolean unterrichtserlaubnis) throws PermissionException {
		if (loginLvl == 1) {
			final ILehrkraft lehrkraft = operator
					.getLehrkraftByLoginName(loginName);
			if (lehrkraft == null) {

				throw new IllegalArgumentException(
						"No Lehrkraft found with that Loginname");
			}

			lehrkraft.setLogin(neuerLogin);
			lehrkraft.setName(name);
			lehrkraft.setArbeitsstunden(stundenProWoche);
			lehrkraft.setPassword(password);
			lehrkraft.setPermissionLvl(permissionLvl);
			lehrkraft.setDarfUnterrichten(unterrichtserlaubnis);

			operator.updateDB(lehrkraft);
			
			if(loginName.equals(user.getLoginName())) {
				user = lehrkraft;
				
			}
		} else {
			throw new PermissionException(
					"You have no Permission to edit an Lehrer");
		}
	}

	/**
	 * gibt alle Lehrer Permissionlvl: min 0
	 * 
	 * @return Liste aller Lehrer
	 * @throws PermissionException
	 *             wenn getLoginlevel() < Permissionlvl
	 */
	public ArrayList<ILehrkraft> getAlleLehrkraefte()
			throws PermissionException {
		if (loginLvl > -1) {
			final ArrayList<IDBObjekt> everything = (ArrayList<IDBObjekt>) operator
					.getAlleDBObjekte();
			final ArrayList<ILehrkraft> lehrer = new ArrayList<ILehrkraft>();
			for (int i = 0; i < everything.size(); i++) {
				if (everything.get(i) instanceof ILehrkraft) {
					lehrer.add((ILehrkraft) everything.get(i));
				}
			}

			return lehrer;

		} else {
			throw new PermissionException("You must be logged in");
		}
	}

	// /**
	// * gibt den Lehrer Permissionlvl: min 0
	// *
	// * @param loginname
	// * Eindeutiger Bezeichner für lehrkräfte
	// * @return Liste aller Lehrer oder null
	// * @throws PermissionException
	// * wenn getLoginlevel() < Permissionlvl
	// */
	// public ILehrkraft getLehrer2(String loginname) throws PermissionException
	// {
	// if (loginLvl > -1) {
	// ILehrkraft lehrkraft = operator.getLehrkraftByLoginName(loginname);
	// if (lehrkraft == null) {
	//
	// throw new IllegalArgumentException(
	// "No Lehrkraft found with that Loginname");
	// }
	//
	// return lehrkraft;
	//
	// } else {
	// throw new PermissionException("You must be logged in for this!");
	// }
	// }

	/**
	 * getter fuer eine beliebige Lehrkraft, kann ein Lehrer oder ein Betreuer
	 * 
	 * @param loginname
	 *            der loginname der lehrkraft
	 * @return die gesuchte lehrkraft
	 * @throws PermissionException
	 *             wenn niemand eingeloggt ist
	 */
	public ILehrkraft getLehrkraft(final String loginname)
			throws PermissionException {
		if (loginLvl > -1) {
			final ILehrkraft lehrkraft = operator
					.getLehrkraftByLoginName(loginname);

			return lehrkraft;

		} else {
			throw new PermissionException("You must be logged in for this!");
		}
	}

	/**
	 * loescht die gegebenen Lehrkraft Permissionlvl: 1
	 * 
	 * @parma loginName eindeutiger Name des Lehrers
	 * @throws PermissionException
	 *             wenn getLoginlevel() < Permissionlvl
	 */
	public void removeLehrkraft(final String loginName)
			throws PermissionException {
		if (loginLvl == 1) {

			operator.removeVonDB(getLehrkraft(loginName));
		} else {
			throw new PermissionException(
					"You have no Permission to remove an Lehrer");
		}
	}

	/**
	 * Aufruf von addKlasse Permissionlvl: 1
	 * 
	 * @param name
	 *            Bezeichner der Klasse
	 * @throws PermissionException
	 *             wenn getLoginlevel() < Permissionlvl
	 */
	public void addKlasse(final String name) throws PermissionException {
		if (loginLvl == 1) {
			operator.schreibeInDB(new Klasse(name));
		} else {
			throw new PermissionException(
					"You have no Permission to add an Klasse");
		}

	}

	/**
	 * gibt alle Klassen
	 * 
	 * @return Liste aller Klassen
	 * 
	 */
	public List<IKlasse> getAlleKlassen() {

		final List<IDBObjekt> everything = operator.getAlleDBObjekte();
		final List<IKlasse> klassen = new ArrayList<IKlasse>();
		for (int i = 0; i < everything.size(); i++) {
			if (everything.get(i) instanceof IKlasse) {
				klassen.add((IKlasse) everything.get(i));
			}
		}

		return klassen;
	}

	/**
	 * gibt die klasse mit dem Namen Permissionlvl: min 0
	 * 
	 * @param name
	 *            Der Name der Gesuchten klasse
	 * @return Die gesuchte Klasse oder null
	 * @throws PermissionException
	 *             wenn getLoginlevel() < Permissionlvl
	 */
	public IKlasse getKlasse(final String name) throws PermissionException {
		if (loginLvl > -1) {
			final IKlasse klasse = operator.getKlasseByName(name);
			return klasse;
		} else {
			throw new PermissionException("You must be logged in for this!");
		}
	}

	/**
	 * loescht die gegebene Klasse Permissionlvl: 1
	 * 
	 * @parma name Name der Klasse
	 * @throws PermissionException
	 *             wenn getLoginlevel() < Permissionlvl
	 */
	public void removeKlasse(final String name) throws PermissionException {
		if (loginLvl == 1) {

			operator.removeVonDB(getKlasse(name));
		} else {
			throw new PermissionException(
					"You have no Permission to remove an Klasse");
		}
	}

	/**
	 * Fuegt eine Aktivitaet hinzu Permissionlvl: 1
	 * 
	 * @param startHours
	 *            die Startuhrzeit in stunden
	 * @param startMin
	 *            die Minuten der Startuhrzeit
	 * @param dauerH
	 *            die Dauer der Aktivitaet in Stunden
	 * @param dauerM
	 *            die Minuten der Dauer der Aktivitaet
	 * @param aktivitaet
	 *            Gibt den namen der Aktivitaet an
	 * @param klassen
	 * @param lehrkraefte
	 * @throws PermissionException
	 *             wenn getLoginlevel() < Permissionlvl
	 * 
	 * @return id der Aktivitaet
	 */
	public Aktivitaet addAktivitaet(final String aktivitaet, final String wochentag,
			final int startHours, final int startMin, final int dauer,
			final List<ILehrkraft> lehrkraefte, final List<IKlasse> klassen)
			throws PermissionException {
		if (loginLvl == 1) {
			final Aktivitaet akti = new Aktivitaet(aktivitaet, wochentag,
					startHours, startMin, dauer);
			for (final ILehrkraft lehr : lehrkraefte) {
				akti.addLehrkraft(lehr);
			}
			for (final IKlasse kla : klassen) {
				akti.addKlasse(kla);
			}
			operator.schreibeInDB(akti);
			return akti;
		} else {
			throw new PermissionException(
					"You have no Permission to add an Aktivitaet");
		}
		
	}

	// /**
	// * Editiert eine Aktivitaet
	// *
	// * @param aktivitaet
	// * die zu bearbeitende Aktivitaet
	// * @param startH
	// * die neue Startuhrzeit in Stunden
	// * @param startM
	// * die neuen Minuten der Startuhrzeit
	// * @param dauerH
	// * die neue Dauer der Aktivitaet in Stunden
	// * @param dauerM
	// * die neue Minutenzahl der Dauer der Aktivitaet
	// * @param name
	// * neuer Aktivitaetsname
	// * @throws PermissionException
	// * wenn getLoginlevel() < Permissionlvl
	// */
	// public void editAktivitaet2(int id, String newStart,
	// String dauer, String name) throws PermissionException {
	// if (loginLvl == 1) {
	// Aktivitaet akti = operator.getAktivitaetByID(id);
	// if(akti != null){
	// akti.setStart(newStart);
	// akti.setDauer(dauer);
	//
	// akti.setName(name);
	//
	// operator.removeVonDB(akti);
	// operator.schreibeInDB(akti);
	// } else {
	// throw new IllegalArgumentException("Aktivitaet not found");
	// }
	// } else {
	// throw new PermissionException(
	// "You have no Permission to edit an Aktivitaet");
	// }
	// }

	// /**
	// * Fuegt eine Lehrkraft(Betreuer oder Lehrer) einer Aktivitaet hinzu
	// * Permissionlvl: 1
	// *
	// * @param aktivitaet
	// * die Aktivitaet der eine Lehrkraft hinzu gefuegt werden soll
	// * @param loginName
	// * eindeutiger Name des Lehrers oder Betreuers
	// * @throws PermissionException
	// * wenn getLoginlevel() < Permissionlvl
	// */
	// public void addLehrkraftZuAktivitaet2(int id, String loginName)
	// throws PermissionException {
	// if (loginLvl == 1) {
	// Aktivitaet akti = operator.getAktivitaetByID(id);
	// try {
	// akti.addLehrkraft(getLehrkraft(loginName));
	// operator.schreibeInDB(akti);
	// } catch (IllegalArgumentException e) {
	// throw new IllegalArgumentException("Lehrkraft not found!");
	// }
	// } else {
	// throw new PermissionException(
	// "You have no Permission to add an Lehrkraft to an Aktivitaet");
	// }
	// }

	// /**
	// * fuegt eine Klasse der Aktivitaet hinzu Permissionlvl: 1
	// *
	// * @param aktivitaet
	// * die Aktivitaet der eine Klasse hinzu gefuegt werden soll
	// * @param name
	// * Bezeichner der Klasse
	// * @throws PermissionException
	// * wenn getLoginlevel() < Permissionlvl
	// */
	// public void addKlasseZuAktivitaet(int id, String klassenName)
	// throws PermissionException {
	// if (loginLvl == 1) {
	// Aktivitaet akti = operator.getAktivitaetByID(id);
	// try {
	// akti.addKlasse(getKlasse(klassenName));
	// operator.schreibeInDB(akti);
	// } catch (IllegalArgumentException e) {
	// throw new IllegalArgumentException("Klasse not found!");
	// }
	// } else {
	// throw new PermissionException(
	// "You have no Permission to add an Klasse to an Aktivitaet");
	// }
	// }

	// /**
	// * Entfernt eine Lehrkraft(Betreuer oder Lehrer) aus einer Aktivitaet
	// * Permissionlvl: 1
	// *
	// * @param aktivitaet
	// * die Aktivitaet aus der eine Lehrkraft entfernt werden soll
	// * @param name
	// * Bezeichner der Klasse
	// * @throws PermissionException
	// * wenn getLoginlevel() < Permissionlvl
	// */
	// public void removeLehrkraftAusAktivitaet(int id,
	// String loginName) throws PermissionException {
	// if (loginLvl == 1) {
	// Aktivitaet akti = operator.getAktivitaetByID(id);
	// try {
	// akti.removeLehrkraft(getLehrkraft(loginName));
	// operator.removeVonDB(operator.getAktivitaetByID(akti.getId()));
	// operator.schreibeInDB(akti);
	// } catch (IllegalArgumentException e) {
	// throw new IllegalArgumentException("Lehrkraft not found");
	// }
	// } else {
	// throw new PermissionException(
	// "You have no Permission to remove an Lehrkraft from an Aktivitaet");
	// }
	// }
	//
	// /**
	// * Entfernt eine Klasse aus einer Aktivitaet Permissionlvl: 1
	// *
	// * @param aktivitaet
	// * die Aktivitaet aus der eine Klasse entfernt werden soll
	// * @param name
	// * Bezeichner der Klasse
	// * @throws PermissionException
	// * wenn getLoginlevel() < Permissionlvl
	// */
	// public void removeKlasseAusAktivitaet(int id, String name)
	// throws PermissionException {
	// if (loginLvl == 1) {
	// Aktivitaet akti = operator.getAktivitaetByID(id);
	// try {
	// akti.removeKlasse(getKlasse(name));
	// operator.removeVonDB(operator.getAktivitaetByID(akti.getId()));
	// operator.schreibeInDB(akti);
	// } catch (IllegalArgumentException e) {
	// throw new IllegalArgumentException("Klasse not found");
	// }
	// } else {
	// throw new PermissionException(
	// "You have no Permission to remove an Klasse from an Aktivitaet");
	// }
	// }

	/**
	 * getter fuer einen Betreuer mit dem uebergebenen Namen
	 * 
	 * @param loginName
	 *            der login des gesuchten Betreuers
	 * @return der gesuchte Betreuer, null falls keiner gefunden wurde
	 * @throws PermissionException
	 *             niemand eingeloggt ist
	 */
	// private Betreuer getBetreuer(String loginName) throws PermissionException
	// {
	// if (loginLvl > -1) {
	// ILehrkraft betreuer = operator.getLehrkraftByLoginName(loginName);
	// if(betreuer != null){
	// if(betreuer instanceof Betreuer){
	// return (Betreuer) betreuer;
	// } else {
	// throw new IllegalArgumentException(betreuer.getName() +
	// "is not an Betreuer");
	// }
	// } else {
	// throw new IllegalArgumentException("Lehrer not found!");
	// }
	// } else {
	// throw new PermissionException("You must be logged in for this!");
	// }
	// }

	/**
	 * Aufruf von addLeher Permissionlvl: 1
	 * 
	 * @param loginName
	 *            eindeutiger Name fuer den Betreuer
	 * @param name
	 *            Name des Betreuer
	 * @param stundenProWoche
	 *            Anzahl der Stunden die ein Betreuer pro Woche arbeiten darf
	 * @throws PermissionException
	 *             wenn getLoginlevel() < Permissionlvl
	 */
	// public void addBetreuer(String loginName, String name, int
	// stundenProWoche,
	// String password, int permissionLvl) throws PermissionException {
	// if (loginLvl == 1) {
	// operator.schreibeInDB(new Betreuer(loginName, stundenProWoche, name,
	// password,
	// permissionLvl));
	// } else {
	// throw new PermissionException(
	// "You have no permission to add an Betreuer");
	// }
	// }

	// /**
	// * zeigt alle Betreuers Permissionlvl: min 0
	// *
	// * @return Liste aller Betreuer
	// * @throws PermissionException
	// * wenn getLoginlevel() < Permissionlvl
	// */
	// public ArrayList<ILehrkraft> getAlleBetreuer() throws PermissionException
	// {
	// if (loginLvl > -1) {
	// ArrayList<IDBObjekt> everything = (ArrayList<IDBObjekt>) operator
	// .getAlleDBObjekte();
	// ArrayList<ILehrkraft> betreuer = new ArrayList<ILehrkraft>();
	// for (int i = 0; i < everything.size(); i++) {
	// if (everything.get(i) instanceof Betreuer) {
	// betreuer.add((Betreuer) everything.get(i));
	// }
	// }
	//
	// return betreuer;
	//
	// } else {
	// throw new PermissionException("You must be logged in");
	// }
	// }

	/**
	 * Gibt alle Aktivitaeten einer Klasse zurueck Permissionlvl: min -1
	 * 
	 * @param name
	 *            Bezeichener der Klasse
	 * @return Liste aller Aktivitaeten fuer die angegebene Klasse
	 * 
	 */
	public List<IAktivitaet> getAlleAktivitaetenFuerKlasse(
			final String klasseName) throws PermissionException {

		final List<IDBObjekt> everything = operator.getAlleDBObjekte();
		final List<IAktivitaet> aktivitaeten = new ArrayList<IAktivitaet>();
		for (int i = 0; i < everything.size(); i++) {
			if (everything.get(i) instanceof Aktivitaet) {
				final List<IKlasse> currentClasses = ((Aktivitaet) everything
						.get(i)).getKlassen();
				for (int k = 0; k < currentClasses.size(); k++) {
					if (currentClasses.get(k).getName().equals(klasseName)) {
						aktivitaeten.add((Aktivitaet) everything.get(i));
					}
				}
			}
		}

		return aktivitaeten;
	}

	/**
	 * Gibt alle Aktivitaeten eines Lehrers oder Betreuers zurueck
	 * Permissionlvl: min 0
	 * 
	 * @param loginName
	 *            eindeutiger Name des Leherers oder Betreuers
	 * @return Liste aller Aktivitaeten fuer den angegebenen Lehrer oder
	 *         Betreuer
	 * @throws PermissionException
	 *             wenn getLoginlevel() < Permissionlvl
	 */
	public List<IAktivitaet> getAlleAktivitaetenFuerLehrerUndBetreuer(
			final String loginName) throws PermissionException {
		if (loginLvl == 1 || loginName.equals(user.getLoginName())) {

			final List<IAktivitaet> aktivitaeten = new ArrayList<IAktivitaet>();
			for (final IDBObjekt object : operator.getAlleDBObjekte()) {
				if (object instanceof Aktivitaet) {
					final Aktivitaet akti = (Aktivitaet) object;
					final List<ILehrkraft> currentLehrkraefte = akti
							.getLehrkraefte();
					for (final ILehrkraft lehr : currentLehrkraefte) {
						if (lehr.getLoginName().equals(loginName)) {
							aktivitaeten.add(akti);
							break; // k = currentLehrkraefte.size();
						}
					}
				}
			}

			return aktivitaeten;

		} else {
			throw new PermissionException("You must be logged in");
		}
	}

	/**
	 * Gibt den derzeit eingeloggten user zurueck permissionLvl: min 0
	 * 
	 * @return der derzeit eingeloggte Nutzer...
	 * @throws PermissionException
	 *             falls niemand eingeloggt ist
	 */
	public ILehrkraft getEingeloggtenNutzer() throws IllegalArgumentException {
		if (user != null) {
			return user;
		} else {
			throw new IllegalArgumentException("No User currently logged in!");
		}
	}

	/**
	 * Eine Methode die die gesamt Arbeitsstunden einer Lehrkraft berechnet und
	 * aus gibt. Kann nur von Lehrkraeften mit der Berechtigungsstufe 1 oder der
	 * jeweiligen Lehrkraft selbst aufgerufen werden.
	 * 
	 * @param lehrkraft
	 *            die Lehrkraft deren Stunden gesucht werden
	 * @return die Gesamtstundenzahl der Lehrkraft
	 * @throws PermissionException
	 *             wird geworfen wenn ein unbefugter versucht Stunden ein zu
	 *             sehen
	 */
	public int getCurrentHours(final String lehrkraft)
			throws PermissionException {
		if (loginLvl == 1 || lehrkraft.equals(user.getLoginName())) {
			int totalHours = 0;
			try {
				final List<IAktivitaet> aktivitaeten = getAlleAktivitaetenFuerLehrerUndBetreuer(lehrkraft);
				for (int i = 0; i < aktivitaeten.size(); i++) {
					totalHours = totalHours + aktivitaeten.get(i).getDauer();
				}
				return totalHours;
			} catch (final IllegalArgumentException e) {
				return totalHours;
			} catch (final PermissionException k) {
				throw new PermissionException("You must be logged in");
			}

		} else {
			throw new PermissionException(
					"You have no rights to view this working hours!");
		}
	}

	/**
	 * loescht die gegebene Aktivitaet Permissionlvl: 1
	 * 
	 * @parma id ID der Aktivitaet
	 * @throws PermissionException
	 *             wenn getLoginlevel() < Permissionlvl
	 */
	public void removeAktivitaet(final int id) throws PermissionException {
		if (loginLvl == 1) {
			operator.removeVonDB(operator.getAktivitaetByID(id));
		} else {
			throw new PermissionException(
					"You have no Permission to remove an Aktivitaet");
		}
	}

	/**
	 * gibt den Datencontroler vom Rechtecontroler zurueck
	 * 
	 * @return der Datencontroler
	 */
	public Datencontroler getDatencontroler() {
		return operator;
	}

	/**
	 * Methode um eine Klasse zu aendern
	 * 
	 * @param oldName
	 *            der Name der Klasse vor der Aenderung
	 * @param newName
	 *            der neue Name der Klasse
	 * @throws PermissionException
	 *             wird geworfen falls der User keine Berechtigung zum
	 *             Bearbeiten einer Klasse hat
	 */
	public void editKlasse(final String oldName, final String newName)
			throws PermissionException {

		if (loginLvl > -1) {
			final Klasse klass = operator.getKlasseByName(oldName);
			if (klass == null) {

				throw new IllegalArgumentException(
						"No Lehrkraft found with that Loginname");
			}
			klass.setName(newName);
			operator.updateDB(klass);

		} else {
			throw new PermissionException("You must be logged in for this!");
		}

	}

	// public List<IAktivitaet> getAlleAktivitaeten() {
	// ArrayList<IDBObjekt> everything = (ArrayList<IDBObjekt>) operator
	// .getAlleDBObjekte();
	// ArrayList<IAktivitaet> aktivitaeten = new ArrayList<IAktivitaet>();
	// for (int i = 0; i < everything.size(); i++) {
	// if (everything.get(i) instanceof Aktivitaet) {
	//
	// aktivitaeten.add((IAktivitaet) everything.get(i));
	// }
	// }
	//
	// return aktivitaeten;
	// }

}